home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / New System Software Extensions / QuickDraw™ GX 1.1.2 / Programming Stuff / QuickDraw™ GX Libraries / Graphics libraries / camera library.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-10  |  4.1 KB  |  112 lines  |  [TEXT/MPS ]
  1. /* graphics libraries:
  2.     Perspective gxMapping generation routines
  3.     by Cary Clark, Georgiann Delaney, Michael Fairman, Dave Good, Robert Johnson, Keith McGreggor, Oliver Steele, David Van Brink, Chris Yerga
  4.     Copyright 1987 - 1991 Apple Computer, Inc.  All rights reserved.    */
  5.  
  6. #include "graphics libraries.h"
  7. #include "camera library.h"
  8.  
  9.  
  10. camera* InitCamera(camera *obscura)
  11. {
  12.     obscura->location.x = 0;
  13.     obscura->location.y = 0;
  14.     obscura->location.z = -IntToFixed(1440);    /* 20 inches backward */
  15.     obscura->axis.x = 0;
  16.     obscura->axis.y = 0;
  17.     obscura->axis.z = fixed1;             /* forward */
  18.     obscura->zenith.x = 0;
  19.     obscura->zenith.y = -fixed1;          /* up */
  20.     obscura->zenith.z = 0;
  21.     obscura->observer.x = 0;
  22.     obscura->observer.y = 0;
  23.     obscura->observer.z = -IntToFixed(1440);    /* 20 inches backward */
  24.     return UpdateCamera(obscura);
  25. }
  26.  
  27. camera* UpdateCamera(camera *obscura)
  28. {
  29.     unit3D temp[2];
  30.     register unit3D *axis = temp;
  31.     register unit3D *zenith = axis + 1;
  32.     Unitize(&obscura->axis, axis);
  33.     {    register Fixed dot = FracDot((unit3D *)&obscura->zenith, axis);
  34.         zenith->x = obscura->zenith.x - FractMultiply(dot, axis->x);
  35.         zenith->y = obscura->zenith.y - FractMultiply(dot, axis->y);
  36.         zenith->z = obscura->zenith.z - FractMultiply(dot, axis->z);
  37.         Unitize((point3D *)zenith, zenith);
  38.     }
  39.     {    register unit3D *destPtr = (unit3D *)&obscura->orientation.map[0][0];
  40.         FracCross(axis, zenith, destPtr++);
  41.         *destPtr++ = *zenith;
  42.         *destPtr++ = *axis;
  43.     }
  44.     {    register Fixed *destPtr = &obscura->orientation.map[0][0];
  45.         register Fixed x = obscura->observer.x;
  46.         register Fixed y = obscura->observer.y;
  47.         register Fixed z = obscura->observer.z;
  48.         destPtr[0] = -FractMultiply(z, destPtr[0]) + FractMultiply(x, destPtr[6]);
  49.         destPtr[1] = -FractMultiply(z, destPtr[1]) + FractMultiply(x, destPtr[7]);
  50.         destPtr[2] = -FractMultiply(z, destPtr[2]) + FractMultiply(x, destPtr[8]);
  51.         destPtr[3] = FractMultiply(z, destPtr[3]) + FractMultiply(y, destPtr[6]);
  52.         destPtr[4] = FractMultiply(z, destPtr[4]) + FractMultiply(y, destPtr[7]);
  53.         destPtr[5] = FractMultiply(z, destPtr[5]) + FractMultiply(y, destPtr[8]);
  54.     }
  55.     return obscura;
  56. }
  57.  
  58. gxMapping* PatchToCameraMap(const patch *quilt, const camera *obscura, gxMapping *map)
  59. {
  60.     register Fixed *destPtr = &map->map[0][0];
  61.     register const Fixed *mapPtr = &obscura->orientation.map[0][0];
  62.     register Fixed *patchPtr;
  63.     point3D diff;
  64.     register Fixed dot;
  65.  
  66.     diff.x = quilt->origin.x - obscura->location.x;
  67.     diff.y = quilt->origin.y - obscura->location.y;
  68.     diff.z = quilt->origin.z - obscura->location.z;
  69.     dot = FracDot((unit3D *)&diff, (unit3D *)&obscura->orientation.map[2][0]);
  70.  
  71.     patchPtr = (Fixed *)quilt;
  72.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr, 1, dot);
  73.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+3, 1, dot);
  74.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+6, 1, dot);
  75.     patchPtr += 3;
  76.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr, 1, dot);
  77.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+3, 1, dot);
  78.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+6, 1, dot);
  79.     patchPtr = (Fixed *)&diff;
  80.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr, 1, dot);
  81.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+3, 1, dot);
  82.     *destPtr = fract1;
  83.     return map;
  84. }
  85.  
  86. Fixed Unitize(const point3D *aPoint, unit3D *bPoint)
  87. {
  88.     register Fixed r = Magnitude(Magnitude(aPoint->x, aPoint->y), aPoint->z);
  89.     if (bPoint)
  90.     {    bPoint->x = FractDivide(aPoint->x, r);
  91.         bPoint->y = FractDivide(aPoint->y, r);
  92.         bPoint->z = FractDivide(aPoint->z, r);
  93.     }
  94.     return r;
  95. }
  96.  
  97. fract FracDot(const unit3D *aPoint, const unit3D *bPoint)
  98. {
  99.     return FractMultiply(aPoint->x, bPoint->x) + FractMultiply(aPoint->y, bPoint->y) + FractMultiply(aPoint->z, bPoint->z);
  100. }
  101.  
  102. unit3D* FracCross(const unit3D *aPoint, const unit3D *bPoint, unit3D *cPoint)
  103. {
  104.     unit3D temp;
  105.     register fract *tempPtr = (fract *)&temp;
  106.     *tempPtr++ = FractMultiply(aPoint->y, bPoint->z) - FractMultiply(aPoint->z, bPoint->y);
  107.     *tempPtr++ = FractMultiply(aPoint->z, bPoint->x) - FractMultiply(aPoint->x, bPoint->z);
  108.     *tempPtr++ = FractMultiply(aPoint->x, bPoint->y) - FractMultiply(aPoint->y, bPoint->x);
  109.     *cPoint = temp;
  110.     return cPoint;
  111. }
  112.